home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / dino / dino_bot.1 / source / library / route.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-27  |  16.6 KB  |  738 lines
  1. /* Copyright, 1990, Regents of the University of Colorado */
  2. #define then /**/
  3. #define NULL 0
  4. #include <stdio.h>
  5. #include "../inc/D_lib.h"
  6. #include "../inc/internal.h"
  7.  
  8. /* routing module
  9.  
  10.     consists of the following exported functions
  11.         D_route_tree_init - initialize routing for tree patterns
  12.         D_route_tree - compute routing for tree patterns
  13.         D_route_cube_init initialize routing for hypercube or butterfly routing
  14.         D_route_cube - compute routing for hypercube routing
  15.  
  16. */
  17.  
  18. /*  imports the following data structures */
  19.  
  20. static ginv(n)
  21.     int n;
  22.  
  23.     /*
  24.  
  25.     ginv = inverse of gray function
  26.  
  27.     answers the inevitable question, what task is being
  28.     carried out on node n?
  29.     */
  30.     
  31.     {
  32.     int i, t;
  33.     t = n/2;
  34.     i = n;
  35.     while(t != 0)
  36.            {
  37.            i = i^t;
  38.            t = t/2;
  39.            }
  40.     return(i);
  41.     }
  42.  
  43. int D_gray(index, entry)
  44.     int index;
  45.     D_env_tbl *entry;
  46.     {
  47.     int i;
  48.     int prod=1, sum=0;
  49.     int mid = 0;
  50.  
  51.     for (i=0; i<entry->n_dims; i++)
  52.         {
  53.         prod <<= entry->mach_dim[i];
  54.         sum += entry->mach_dim[i];
  55.         }
  56.     for (i=0; i<entry->n_dims; i++)
  57.         {
  58.         int t;
  59.         sum -= entry->mach_dim[i];
  60.         prod >>= entry->mach_dim[i];
  61.         t = (index >> sum);
  62.         mid += (t^(t/2));
  63.         mid *= prod;
  64.         index ^= t<<sum;
  65.         }
  66.     return mid;
  67.     }
  68.  
  69. int D_ginv(index, entry)
  70.     int index;
  71.     D_env_tbl *entry;
  72.     {
  73.     int i;
  74.     int prod=1, sum=0;
  75.     int mid = 0;
  76.  
  77.     for (i=0; i<entry->n_dims; i++)
  78.         {
  79.         prod <<= entry->mach_dim[i];
  80.         sum += entry->mach_dim[i];
  81.         }
  82.     for (i=0; i<entry->n_dims; i++)
  83.         {
  84.         int t;
  85.         sum -= entry->mach_dim[i];
  86.         prod >>= entry->mach_dim[i];
  87.         t = (index >> sum);
  88.         mid += ginv(t);
  89.         mid *= prod;
  90.         index ^= t<<sum;
  91.         }
  92.     return mid;
  93.     }
  94.  
  95. /* D_find_parent
  96. *
  97. *   Purpose :   find parent of this node
  98. *
  99. *   Input :  index of env, mask of first parent, bitmap, number of root 
  100. *
  101. *   Output :    parent id
  102. */
  103. int D_find_parent(index, mask, bitmap, root)
  104.     int index,mask,root;
  105.     D_BOOL bitmap[];
  106.     {
  107.     while ((mask > 0)  && !(bitmap[index ^ mask])){
  108.         index ^= mask;
  109.         mask >>=1;
  110.         }
  111.     return (mask != 0)?
  112.         index ^ mask:
  113.         root;
  114.     }
  115.  
  116.  
  117. /* D_set_stack
  118. *
  119. *   Purpose :   determine all children this env will send to
  120. *
  121. *   Input :  bitmap, index of env to check, size of envstructure, current bit,
  122. *              if this node must handle the node 0's children also
  123. *
  124. *   Output :    stack (a bitmap) has all the nodes which index will send to set,
  125. *              this returns if there are any children
  126. */
  127. D_BOOL D_set_stack(bitmap, stack, index, size, mask, do_root)
  128.     D_BOOL bitmap[];
  129.     D_BOOL stack[];
  130.     int index;
  131.     int size;
  132.     int mask;
  133.     D_BOOL do_root;
  134.     {
  135.     int t;
  136.     D_BOOL res = FALSE;
  137.  
  138.     if (do_root){
  139.         res = D_set_stack(bitmap, stack, 0, size, 1, FALSE);
  140.         stack[index] = 0;
  141.         }
  142.     for (; (t = mask^index) < size; mask <<= 1)
  143.         if (bitmap[t])
  144.             then{
  145.                 res =1;
  146.                 stack[t] = 1;
  147.                 }
  148.             else{
  149.                 D_BOOL tres = D_set_stack(bitmap,stack,t, size, mask<<1, FALSE);
  150.                 res = res || tres;
  151.                 }
  152.     return res;
  153.     }
  154.  
  155. /* D_grand_children
  156. *
  157. *   Purpose :   determine all children below a certain child
  158. *
  159. *   Input :  bitmap, if the bitmap should not be used, where to put the 
  160. *              results, index of env to check (processor number!), 
  161. *              size of envstructure, current bit,
  162. *              if this node must handle the node 0's children also,
  163. *              entry into env_table
  164. *
  165. *   Output :    stack (a bitmap) has all the nodes which index will send to set,
  166. *              this returns pointer to next stack location
  167. */
  168. short int *D_grand_children(
  169.         bitmap, implicit, stack, index, size, mask,do_root,entry)
  170.     D_BOOL bitmap[];
  171.     D_BOOL implicit;
  172.     short int *stack;
  173.     int index;
  174.     int size;
  175.     int mask;
  176.     D_BOOL do_root;
  177.     D_env_tbl *entry;
  178.     {
  179.     int vmach, /*machine processor number*/
  180.         proc; /*index into environment structure*/
  181.  
  182.     if (do_root){
  183.         stack = D_grand_children(
  184.                 bitmap, implicit, stack, 0, size, 1, FALSE,entry);
  185.         }
  186.     vmach = mask^index;
  187.     proc = D_ginv(vmach,entry);
  188.     while (proc<size){
  189.         if (implicit?1:bitmap[vmach])
  190.             then{
  191.                 *stack = proc;
  192.                 stack = D_grand_children(
  193.                     bitmap,implicit,++stack,vmach,size, mask<<1, FALSE,entry);
  194.                 }
  195.             else{
  196.                 stack = D_grand_children(
  197.                     bitmap,implicit,++stack,vmach, size, mask<<1, FALSE,entry);
  198.                 }
  199.         mask <<=1;
  200.         vmach = mask^index;
  201.         proc = D_ginv(vmach,entry);
  202.         }
  203.     return stack;
  204.     }
  205.  
  206.  
  207.  
  208. /* D_high_bit
  209. *
  210. *   Purpose :   find highest bit set in an int
  211. *
  212. *   Input :  int
  213. *
  214. *   Output :    everything but the highest bit masked off
  215. *
  216. */
  217. int D_high_bit(x)
  218.     int x;
  219.     {
  220.     register unsigned int i = 1 << (8*sizeof(int) - 2);
  221.     for(;(i>0) && !(i&x); i=i >> 1);
  222.     return i;
  223.     };
  224.  
  225. int which_bit(x)
  226. unsigned int x;
  227.         {
  228.         int count=0;
  229.         for (;x>0;x=x >> 1) count++;
  230.         if (count>0) count--; 
  231.         return(count);
  232.         };
  233.  
  234.  
  235.  
  236. /* static values for tree routing */
  237. static D_BOOL pt_pt;
  238. static envvar child, parent;
  239. static int child_que; /*next child to send out*/
  240. static D_BOOL is_root;
  241. static int next_child; /*bit mask of bit to be flipped*/
  242. static int stack_crnt;
  243. static my_gray;
  244.  
  245. /* D_route_tree_init
  246. *
  247. *   Purpose :   initialize tree routing
  248. *
  249. *   Input :  env - pointer to an envset (there can only be one envset)
  250. *              off_parent - parent env if not on this structure
  251. *
  252. *   Output :    if this is root of tree then off_parent else parent of this node
  253. */
  254. envvar *D_route_tree_init(env, done, off_parent)
  255.     D_env_set *env;
  256.     D_BOOL *done;
  257.     envvar *off_parent;
  258.     {
  259.     my_gray = D_gray(D_my_env.index, &D_env_table[D_my_env.name]);
  260.     /*compute pt_pt*/
  261.     if (D_my_env.name != env->name)
  262.         pt_pt = TRUE;
  263.     else if ((env->count != 1) || 
  264.             ((env->implicit) && (D_env_table[env->name].size>1)))
  265.         pt_pt = FALSE;
  266.     else{
  267.         if (env->implicit)
  268.             pt_pt = FALSE;
  269.         else{
  270.             register int sum = 0;
  271.             register D_BOOL *pt = env->bitmap;
  272.             D_BOOL *last = &(env->bitmap[D_env_table[env->name].size-1]);
  273.             for (; pt <=last; pt++)
  274.                 sum += *pt;
  275.             pt_pt = (sum == 1);
  276.             }
  277.         }
  278.  
  279.     if (pt_pt){
  280.         child.name = env->name;
  281.         if (env->implicit)
  282.             then child.index = 0;
  283.             else{
  284.                 register D_BOOL *p = env->bitmap;
  285.                 for (;*p!=1;p++);
  286.                 child.index = D_ginv(p - env->bitmap, &D_env_table[env->name]); 
  287.                 }
  288.         *done = FALSE;
  289.         return off_parent;
  290.         }
  291.     else{
  292.         register int high_me;
  293.         int size;
  294.         int root = 0;
  295.         unsigned int virtual_dim;
  296.         D_BOOL is_child;
  297.  
  298.         size = D_env_table[D_my_env.name].size;
  299.         virtual_dim = D_high_bit(size);
  300.         virtual_dim =(size & ~virtual_dim)?(virtual_dim<<1):virtual_dim;
  301.         high_me = D_high_bit(my_gray);
  302.  
  303.         /*determine if this is root of tree*/
  304.         if ((env->name != D_my_env.name) ||
  305.                 (env->implicit && (my_gray == 0)))
  306.             then is_root = TRUE;
  307.             else if(env->implicit)
  308.                 then is_root= FALSE;
  309.                 else{
  310.                     register D_BOOL *p, 
  311.                         *stop = &(env->bitmap[my_gray]);
  312.                     is_root = TRUE;
  313.                     for (p=env->bitmap; p<stop; p++)
  314.                         if (*p){
  315.                             is_root = FALSE;
  316.                             root = p - env->bitmap;
  317.                             break;}
  318.                     }
  319.  
  320.         /*compute who to send to*/
  321.         if (!env->implicit && (env->name == D_my_env.name))
  322.             {
  323.             register int i;
  324.             for (i=0; i<size; i++)
  325.                 D_route_stack[i] = 0;
  326.             is_child = D_set_stack(
  327.                 env->bitmap, D_route_stack,
  328.                 my_gray, size,
  329.                 (high_me == 0? 1 : high_me<<1),
  330.                 is_root&& my_gray!=0);
  331.             stack_crnt = my_gray;
  332.             if(is_child) 
  333.                 then{
  334.                     child.name = D_my_env.name;
  335.                     for (; stack_crnt<size && !D_route_stack[stack_crnt];
  336.                         stack_crnt++);
  337.                     *done = stack_crnt == size;
  338.                     child_que = stack_crnt++;
  339.                     }
  340.                 else *done = TRUE;
  341.  
  342.             }
  343.         else if(env->implicit && (env->name == D_my_env.name))
  344.             {
  345.             child.name = D_my_env.name;
  346.             next_child = 
  347.                 high_me ?
  348.                     high_me << 1 :
  349.                     1;
  350.             child_que = my_gray ^ next_child;
  351.             *done = (D_ginv(child_que, &D_env_table[env->name]) >= size);
  352.             next_child <<= 1;
  353.             }
  354.         else
  355.             { /*find first non zero env to send to*/
  356.             child.name = env->name;
  357.             if (env->implicit)
  358.                 then {
  359.                     child_que = 0;
  360.                     *done = FALSE;
  361.                     }
  362.                 else {
  363.                     for (child_que=0; 
  364.                         child_que<size && (env->bitmap[child_que] == 0);
  365.                         child_que++);
  366.                     *done = !env->bitmap[child_que];
  367.                     }
  368.             }
  369.  
  370.         /*compute parent (if there is one)*/ 
  371.         if (is_root) 
  372.             return off_parent; 
  373.             else{
  374.                 parent.name = D_my_env.name;
  375.                 parent.index =  (env->implicit) ?
  376.                     high_me ^ my_gray :
  377.                     D_find_parent(my_gray, high_me, env->bitmap, root);
  378.                 parent.index = D_ginv(parent.index, &D_env_table[env->name]);
  379.                 return &parent;
  380.                 }
  381.         }
  382.     }
  383.  
  384. /* D_route_tree
  385. *
  386. *   Purpose :   tree routing
  387. *
  388. *   Input :  env - pointer to an envset
  389. *              done - flag to return if there are no children
  390. *
  391. *   Output :    pointer to child envvar, 
  392. *              done - set true if there are no more children after this
  393. */
  394. envvar *D_route_tree(env, done, children)
  395.     D_env_set *env;
  396.     D_BOOL *done;
  397.     short int **children;
  398.     {
  399.     if (pt_pt){
  400.  
  401.         *done = TRUE;
  402.         *children = D_route_children;
  403.         if (env->name != D_my_env.name)
  404.             then {
  405.                 int child_high = D_high_bit(child_que);
  406.                 short int *end;
  407.  
  408.                 end = D_grand_children(
  409.                     env->bitmap, env->implicit,D_route_children,
  410.                     child_que, D_env_table[env->name].size,
  411.                     (child_high==0)?1:(child_high<<1),FALSE,
  412.                     &D_env_table[env->name]);
  413.                 *end = -1;
  414.                 }
  415.             else D_route_children[0] = -1;
  416.         }
  417.     else {
  418.         int size = D_env_table[D_my_env.name].size;
  419.         int child_high = D_high_bit(child_que);
  420.         short int *end;
  421.  
  422.         child.index = D_ginv(child_que, &D_env_table[env->name]);
  423.          *children = D_route_children;
  424.         D_route_children[0] = -1;
  425.         end = D_grand_children(
  426.             env->bitmap,env->implicit,D_route_children,
  427.             child_que,size,child_high<<1,FALSE,
  428.             &D_env_table[env->name]);
  429.         *end = -1;
  430.         if (env->implicit){
  431.             child_que = my_gray ^ next_child;
  432.             *done = D_ginv(child_que, &D_env_table[env->name]) >= size;
  433.             next_child <<=1;
  434.             }
  435.         else{
  436.             for (; stack_crnt < size && !D_route_stack[stack_crnt];
  437.                 stack_crnt++);
  438.             *done = (stack_crnt == size) || env->name != D_my_env.name;
  439.             child_que = stack_crnt++;
  440.             }
  441.         }
  442.     return &child;
  443.     }
  444.  
  445.  
  446.  
  447. /*static values for cube routing */
  448.  
  449. static D_BOOL is_simple_cube;
  450. static D_BOOL is_stack_empty;
  451. static D_env_set *my_set, *crnt_set;
  452. static int crnt_index;
  453. static D_BOOL done_me;
  454. static int my_root;
  455. static int bit; /*bit currently flipping*/
  456. static unsigned int maxstep;
  457. static int size,done_size;
  458.  
  459. static int D_parent(target, next, parent, logtarget, my_set,env,size)
  460.     int target, next, *parent, *logtarget;
  461.     D_env_set *my_set;
  462.     D_env_set *env;
  463.     int size;
  464.     {
  465.     int pfound, neigh;
  466.  
  467.     pfound = FALSE;
  468.     for(neigh=1; neigh<next && !pfound; neigh<<=1){
  469.         *logtarget = D_ginv(
  470.             *parent = (target^neigh),
  471.             &D_env_table[env->name]);
  472.         if (env->implicit || env->allflag)
  473.             pfound = (size >  *logtarget);
  474.         else if    ((my_set->bitmap[*logtarget]) && (size > *logtarget))
  475.             pfound = TRUE;
  476.         if (!pfound && (neigh>1))
  477.             pfound=D_parent(*parent,neigh,parent,
  478.                 logtarget,my_set,env,size);
  479.     }
  480.     return pfound;
  481.     }
  482. D_cube_stack(next_child,target,p,logtarget,my_set,env,size,start)
  483.     int next_child,target,*p,*logtarget;
  484.     D_env_set *my_set;
  485.     D_env_set *env;
  486.     int size,start;
  487.     {
  488.     int c,ind;
  489.     for(c=start/2; c>0; c>>=1){
  490.         ind=target^c;
  491.         if (!D_parent(ind,  next_child<<1, 
  492.             p, logtarget, my_set, env,size))
  493.                 D_route_stack[ind] = TRUE;
  494.         else if(*logtarget==D_my_env.index)
  495.                 D_route_stack[ind] = TRUE;
  496.         if (c > 1) D_cube_stack(next_child,ind,p,logtarget,my_set,env,size,c);
  497.     }
  498.     return;
  499.     }
  500.  
  501.  
  502.  
  503. /* D_route_cube_init
  504. *
  505. *   Purpose :   initialize cube routing
  506. *
  507. *   Input :  env - pointer to an envset(s)
  508. *
  509. *   Output :    
  510. */
  511. D_route_cube_init(env)
  512.     D_env_set *env;
  513.     {
  514.     int i;
  515.     int high_bit, maxsize;
  516.  
  517.     for (i=0; (i<env->count) && (env[i].name != D_my_env.name); i++);
  518.     my_set = (env[i].name != D_my_env.name)? NULL : &env[i];
  519.     crnt_set = (env->name == D_my_env.name)
  520.         ? (env->count == 1
  521.             ? NULL
  522.             : &env[1])
  523.         : env;
  524.     crnt_index = (env->name == D_my_env.name)
  525.         ? (env->count == 1
  526.             ? 0
  527.             : 1)
  528.         : 0;
  529.     if (my_set == NULL)
  530.         return;
  531.  
  532.     my_gray = D_gray(D_my_env.index, &D_env_table[D_my_env.name]);
  533.     size = D_env_table[D_my_env.name].size;
  534.     high_bit = D_high_bit(size);
  535.     is_simple_cube = ((high_bit ^ size) == 0) && my_set->implicit; /*power of 2*/
  536.  
  537.     maxsize=0;
  538.     for (i=0;i<env->count;i++)
  539.         if (D_env_table[env[i].name].size > maxsize) 
  540.             maxsize=D_env_table[env[i].name].size;
  541.     maxstep=D_high_bit(maxsize);
  542.     maxstep=(maxsize & ~maxstep)?(maxstep<<1):maxstep;
  543.     maxstep=which_bit(maxstep);
  544.     done_size=size;
  545.  
  546.     
  547.     if (!is_simple_cube)
  548.         {
  549.         register int i,count;
  550.         register int high;
  551.         int maxone=0;
  552.         done_size=0;
  553.  
  554.         if (!(my_set->implicit))
  555.         {
  556.             for (i=0;i<size;i++)
  557.                 if(my_set->bitmap[i]){
  558.                     done_size++;
  559.                     maxone=i+1;
  560.                 }
  561.             size = D_min(size,maxone);
  562.             if (size < (2 * done_size)) done_size=size;
  563.         } 
  564.         else done_size=size;
  565.  
  566.         high = (high_bit ^ size) == 0 ? high_bit : high_bit << /*+*/ 1;
  567.         for (i=0; i< high; i++)
  568.             D_route_stack[i] = 0;
  569.         is_stack_empty = TRUE;
  570.         if (my_set->implicit || my_set->allflag)
  571.             count = size;
  572.         else for (i=count=0; i<size && count <2; i++)
  573.                 count += my_set->bitmap[i];
  574.         done_me = (count < 2);
  575.         }
  576.         else  done_me = done_size == 1;
  577.     child.name = D_my_env.name;
  578.     next_child = 1;
  579.     bit = 0;
  580.     if (my_set -> implicit || my_set -> allflag)
  581.         my_root = 0;
  582.         else {
  583.             register char *i,*s;
  584.             for (i=my_set->bitmap, s=(char *)&my_set->bitmap[size]; (i<s)&& !*i; i++);
  585.             my_root = i-my_set->bitmap;
  586.             }
  587.     }
  588.  
  589.  
  590. /* D_route_cube
  591. *
  592. *   Purpose :   cube routing
  593. *
  594. *   Input :  env - pointer to an envset(s)
  595. *
  596. *   Output :    done set if no more partners
  597. *              tree set to bitmap if value must be sent to a group
  598. *              type describes who goes where:
  599. *                  D_route_pair : send and recv from the returned envvar
  600. *                  D_route_rcvsnd : receive from the envvar, send to tree bitmap
  601. *                          if tree is null then send to all
  602. *                  D_route_recv : receive from returned envvar
  603. */
  604. envvar *D_route_cube(env,done,tree,type,bitpt)
  605.     D_env_set *env;
  606.     D_BOOL *done;
  607.     D_BOOL **tree;
  608.     D_route_type *type;
  609.     int *bitpt;
  610.     {
  611.     D_BOOL setbit = TRUE;
  612.  
  613.     if(!done_me)
  614.     if (is_simple_cube)
  615.         then {
  616.             child.index = D_ginv(my_gray ^ next_child, 
  617.                             &D_env_table[env->name]);
  618.             next_child <<= 1;
  619.             *bitpt = bit++;
  620.             done_me = next_child >= done_size;
  621.             *tree = NULL;
  622.             *type = D_route_pair;
  623.             }
  624.         else {
  625.             D_BOOL found = FALSE;
  626.             int target, logtarget;
  627.  
  628.             while (!found /*  && (next_child < size) */ ){ /*find recv*/
  629.                 setbit = TRUE;
  630.                 target = my_gray ^ next_child;
  631.                 logtarget = D_ginv(target,&D_env_table[env->name]);
  632.                 if ( !env->implicit && !env->allflag && (!my_set->bitmap[logtarget] || size < logtarget)) setbit=FALSE;
  633.  
  634.                 if ((logtarget <size) ? /*this is a valid point in envset*/
  635.                         ((env->implicit || env->allflag) 
  636.                             ? TRUE : my_set->bitmap[logtarget]):
  637.                         FALSE)
  638.                     then {
  639.                         found = TRUE;
  640.                         *type = D_route_pair;
  641.                         }
  642.                     else {
  643.                         int parent, pfound;
  644.  
  645.                         pfound = D_parent(target, next_child, 
  646.                                 &parent, &logtarget, my_set, env,size);
  647.                         if ((!pfound) || (parent^target) >= next_child) 
  648.                             then {
  649.                                 int p,c;
  650.  
  651.                                 is_stack_empty = FALSE;
  652.                                 D_route_stack[target] = TRUE;
  653.                                 D_cube_stack(next_child,target,&p,&logtarget,
  654.                                             my_set,env,size,next_child);
  655.                                 next_child <<=1;
  656.                                 *bitpt = bit++;
  657.                                 *type = D_route_rcvsnd;
  658.                                 }
  659.                             else {
  660.                                 found = TRUE;
  661.                                 *type = D_route_recv;
  662.                                 } 
  663.                         target = parent;
  664.                         }
  665.                 }
  666.             if (is_stack_empty)
  667.                 then{
  668.                     child.index = logtarget;
  669.                     next_child <<= 1;
  670.                     *bitpt = bit++;
  671.                     *tree = 0;
  672.                     }
  673.                 else {
  674.                     register int i,in,lin,high,high_bit;
  675.  
  676.                     child.index = logtarget;
  677.                     for (i=0; i<size; i++)
  678.                         D_route_tree_map[i]=0;
  679.                     high_bit = D_high_bit(size);
  680.                     high = (high_bit ^ size) == 0 ? high_bit : high_bit<</*+*/1;
  681. /*                    for (i=0; i<size; i++){ */
  682.                     for (i=0; i<high; i++){
  683.                         if (D_route_stack[i])
  684.                             {
  685.                             in = i ^ next_child;
  686.                             lin = D_ginv(in,&D_env_table[env->name]);
  687.                             D_route_tree_map[lin] =
  688.                                 ( lin <  size && ( my_set->implicit || my_set -> allflag)) ?
  689.                                     1 :
  690.                                     my_set->bitmap[lin] && lin < size;
  691.                             }
  692.                         }
  693.  
  694.                  if (setbit)
  695.                     D_route_tree_map[logtarget] = 1;  /*add this child */
  696.                     *tree = D_route_tree_map;
  697.                     *type = D_route_rcvsnd;
  698.                     next_child <<= 1;
  699.                     *bitpt = bit++;
  700.                     }
  701.             done_me = next_child >= done_size;
  702.             *done = done_me && (env->count==1);
  703.             return &child;
  704.             }
  705.     else if (crnt_set != NULL){
  706.         child.name = crnt_set->name;
  707.         if (crnt_set -> implicit || crnt_set -> allflag)
  708.             then child.index = 0;
  709.             else {
  710.                 register D_BOOL *i, *s;
  711.                 for(i=crnt_set->bitmap, 
  712.                     s=(D_BOOL *)&(crnt_set->bitmap[D_env_table[crnt_set->name].size]);
  713.                     i<s && !*i; i++);
  714.                 child.index = D_ginv(i-crnt_set->bitmap,&D_env_table[env->name]);
  715.                 };
  716.         if (my_root == my_gray)
  717.             then {
  718.                 *type = D_route_rcvsnd;
  719.                 *tree = (crnt_set -> implicit || crnt_set->allflag)
  720.                     ? NULL
  721.                     : crnt_set->bitmap;
  722.                 *bitpt=maxstep;
  723.                 }
  724.             else *type = D_route_recv;
  725.         crnt_index++;
  726.         if ((crnt_index >= env->count) || 
  727.                 ((my_set->name == env[crnt_index].name) && (crnt_set==env)))
  728.             then crnt_set = NULL;
  729.             else if(my_set->name == env[crnt_index].name)
  730.                 then crnt_set+=2;
  731.                 else crnt_set++;
  732.         }
  733.     *done = done_me && (crnt_set == NULL);
  734.     return &child;
  735.     }
  736.  
  737.  
  738.